package com.lekang.service.impl;

import java.util.Date;
import java.util.List;
import com.lekang.common.utils.DateUtils;
import com.lekang.common.utils.SecurityUtils;
import com.lekang.domain.OrderManagement;
import com.lekang.service.IOrderManagementService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.lekang.mapper.TaskArrangementMapper;
import com.lekang.domain.TaskArrangement;
import com.lekang.service.ITaskArrangementService;

/**
 * 任务安排Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-10-16
 */
@Service
public class TaskArrangementServiceImpl implements ITaskArrangementService 
{
    @Autowired
    private TaskArrangementMapper taskArrangementMapper;

    @Autowired
    private IOrderManagementService orderManagementService;

    /**
     * 查询任务安排
     * 
     * @param id 任务安排主键
     * @return 任务安排
     */
    @Override
    public TaskArrangement selectTaskArrangementById(Long id)
    {
        return taskArrangementMapper.selectTaskArrangementById(id);
    }

    /**
     * 查询任务安排列表
     * 
     * @param taskArrangement 任务安排
     * @return 任务安排
     */
    @Override
    public List<TaskArrangement> selectTaskArrangementList(TaskArrangement taskArrangement)
    {
        // 获取当前登录用户ID
        Long currentUserId = SecurityUtils.getUserId();
        
        // 判断当前用户是否是护理员角色
        // 如果用户角色包含护理员角色，则只能查看分配给自己的任务
        if (SecurityUtils.getLoginUser().getUser().getRoles().stream()
                .anyMatch(role -> "caregiver".equals(role.getRoleKey()) 
                    || "huliyuan".equals(role.getRoleKey()) 
                    || "护理员".equals(role.getRoleName()))) {
            // 设置查询条件：只查询分配给当前护理员的任务
            taskArrangement.setCaregiverId(currentUserId);
            System.out.println("护理员登录，只查询自己的任务。护理员ID：" + currentUserId);
        } else {
            System.out.println("管理员或其他角色登录，可查看所有任务。用户ID：" + currentUserId);
        }
        
        return taskArrangementMapper.selectTaskArrangementList(taskArrangement);
    }

    /**
     * 新增任务安排
     * 
     * @param taskArrangement 任务安排
     * @return 结果
     */
    @Override
    public int insertTaskArrangement(TaskArrangement taskArrangement)
    {
        taskArrangement.setCreateTime(DateUtils.getNowDate());
        return taskArrangementMapper.insertTaskArrangement(taskArrangement);
    }

    /**
     * 修改任务安排
     * 
     * @param taskArrangement 任务安排
     * @return 结果
     */
    @Override
    public int updateTaskArrangement(TaskArrangement taskArrangement)
    {
        return taskArrangementMapper.updateTaskArrangement(taskArrangement);
    }

    /**
     * 批量删除任务安排
     * 
     * @param ids 需要删除的任务安排主键
     * @return 结果
     */
    @Override
    public int deleteTaskArrangementByIds(Long[] ids)
    {
        return taskArrangementMapper.deleteTaskArrangementByIds(ids);
    }

    /**
     * 删除任务安排信息
     * 
     * @param id 任务安排主键
     * @return 结果
     */
    @Override
    public int deleteTaskArrangementById(Long id)
    {
        return taskArrangementMapper.deleteTaskArrangementById(id);
    }

    @Override
    public int cancelTask(Long taskId, String cancelReason) {
        TaskArrangement task = new TaskArrangement();
        task.setId(taskId);
        task.setStatus("已取消"); // 状态改为“已取消”
        task.setCancelTime(new Date()); // 取消时间为当前时间
        task.setCancelPerson(SecurityUtils.getUserId()); // 取消人为当前登录用户（需工具类支持）
        task.setCancelReason(cancelReason);
        return taskArrangementMapper.updateTaskArrangement(task);
    }

    @Override
    public int executeTask(Long taskId, Date executionTime, String executionImage, String executionRecord) {
        // 先查询任务信息，获取关联订单号
        TaskArrangement existingTask = taskArrangementMapper.selectTaskArrangementById(taskId);
        
        // 如果任务有关联订单号，则更新订单状态
        if (existingTask != null && existingTask.getRelatedOrderNo() != null && !existingTask.getRelatedOrderNo().isEmpty()) {
            OrderManagement orderManagement = orderManagementService.selectOrderManagementByOrderNO(existingTask.getRelatedOrderNo());
            if (orderManagement != null) {
                orderManagement.setOrderStatus(2L); // 将订单状态从1改为2
                int i = orderManagementService.updateOrderManagement(orderManagement);
                System.out.println("执行任务-订单状态更新结果：" + i + "，订单号：" + existingTask.getRelatedOrderNo());
            } else {
                System.out.println("执行任务-未找到关联订单，订单号：" + existingTask.getRelatedOrderNo());
            }
        } else {
            System.out.println("执行任务-任务没有关联订单号，跳过订单状态更新");
        }

        // 更新任务状态为"已执行"
        TaskArrangement task = new TaskArrangement();
        task.setId(taskId);
        task.setStatus("已执行"); // 状态改为"已执行"
        task.setExecutionTime(executionTime);
        task.setExecutionImage(executionImage);
        task.setExecutionRecord(executionRecord);
        task.setExecutor(SecurityUtils.getUserId()); // 执行人为当前登录用户
        return taskArrangementMapper.updateTaskArrangement(task);
    }

    @Override
    public int rescheduleTask(Long taskId, Date newExpectedTime, Date rescheduleTime) {
        TaskArrangement task = new TaskArrangement();
        task.setId(taskId);
        task.setExpectedServiceTime(newExpectedTime); // 更新期望服务时间
        task.setRescheduleTime(rescheduleTime); // 改期时间为当前操作时间
        task.setStatus("待执行"); // 改期后仍为"待执行"
        return taskArrangementMapper.updateTaskArrangement(task);
    }

    /**
     * 根据关联单据号查询任务安排
     * 
     * @param relatedOrderNo 关联单据号
     * @return 任务安排
     */
    @Override
    public TaskArrangement selectTaskArrangementByRelatedOrderNo(String relatedOrderNo)
    {
        return taskArrangementMapper.selectTaskArrangementByRelatedOrderNo(relatedOrderNo);
    }
}
